/**
 * 请求封装工具
 * 统一处理请求、响应、错误等
 */

// 创建翻译函数
const t = (key) => {
	// 从全局获取 i18n 实例
	const app = getApp && getApp()
	if (app && app.$i18n && app.$i18n.t) {
		return app.$i18n.t(key)
	} else if (app && app.$i18n && app.$i18n.global && app.$i18n.global.t) {
		return app.$i18n.global.t(key)
	}

	// 如果无法获取全局 i18n 实例，尝试直接使用 uni.getStorageSync 获取当前语言
	const currentLanguage = uni.getStorageSync('currentLanguage') || 'zh-Hans'

	// 定义默认消息映射
	const defaultMessages = {
		'zh-Hans': {
			'net.loading': '加载中...',
			'net.otherError': '其他错误',
			'net.loginExpired': '登录失效',
			'net.insufficientPermissions': '权限不足',
			'net.resourceDoesNotExist': '资源不存在',
			'net.networkError': '网络错误',
			'net.httpError': 'HTTP错误',
			'net.networkConnectionAbnormal': '网络连接异常'
		},
		'en': {
			'net.loading': 'Loading...',
			'net.otherError': 'Other error',
			'net.loginExpired': 'Login expired',
			'net.insufficientPermissions': 'Insufficient permissions',
			'net.resourceDoesNotExist': 'Resource does not exist',
			'net.networkError': 'Network error',
			'net.httpError': 'HTTP error',
			'net.networkConnectionAbnormal': 'Network connection abnormal'
		}
	}

	return (defaultMessages[currentLanguage] && defaultMessages[currentLanguage][key]) || key
}

// 基础域名配置
const baseUrls = {
	development: 'https://api.zymofang.com/api',
	test: 'https://test-api.example.com',
	production: 'https://api.example.com'
}

// 获取当前环境的基础域名
const getBaseUrl = () => {
	// #ifdef H5
	// return baseUrls[process.env.NODE_ENV || 'development']
	// #endif

	// 非H5环境可手动切换环境
	return baseUrls['development']
}

// 请求拦截器
const requestInterceptor = (options) => {
	// 拼接完整URL
	if (!options.url.startsWith('http')) {
		options.url = getBaseUrl() + options.url
	}

	// 设置默认请求头
	options.header = {
		'Content-Type': 'application/json',
		...options.header
	}

	// 添加token
	const token = uni.getStorageSync('token')
	if (token) {
		options.header.Authorization = `Bearer ${token}`
	}

	// 显示加载中
	if (options.showLoading !== false) {
		uni.showLoading({
			title: options.loadingText || t('net.loading'),
			mask: true
		})
	}

	return options
}

// 响应拦截器
const responseInterceptor = (response, config = {}) => {
	// 隐藏加载中
	if (config.showLoading !== false) {
		uni.hideLoading()
	}

	const {
		data,
		statusCode
	} = response
	console.log('http响应数据:', data)
	console.log('http状态码:', statusCode)
	// HTTP状态码错误
	if (statusCode == 200) {
		//http 200
		if (data.code == 200) {
			//接口状态码 200
			return data.data
		} else {
			//接口状态吗 其他错误，显示错误码 方便定位错误
			console.log('响应数据 data.code :', data.code)
			return Promise.reject(new Error(`${data.message}: ${data.code}`))
		}
	} else if (statusCode == 401) {
		//登录失效，接口返回登录失效 会先在http状态下优先拦截
		uni.removeStorageSync('token')
		uni.showToast({
			title: `${t('net.loginExpired')}: ${statusCode} ${data.response}`,
			icon: 'none'
		})
		console.log('跳转登录页 data.code :', data.code, statusCode)
		uni.navigateTo({
			url: '/pages/login/login'
		})
	} else if (statusCode == 403) {
		//请求权限不足
		uni.showToast({
			title: `${t('net.insufficientPermissions')}: ${statusCode} ${data.response}`,
			icon: 'none'
		})
		return Promise.reject(new Error(`${t('net.insufficientPermissions')}: ${statusCode}`))
	} else if (statusCode == 404) {
		//请求资源不存在
		uni.showToast({
			title: `${t('net.resourceDoesNotExist')}: ${statusCode} ${data.response}`,
			icon: 'none'
		})
		return Promise.reject(new Error(`${t('net.resourceDoesNotExist')}: ${statusCode}`))
	} else {
		//其他http状态错误
		uni.showToast({
			title: `${t('net.networkError')}: ${statusCode}`,
			icon: 'none'
		})
		return Promise.reject(new Error(`${t('net.httpError')}: ${statusCode}`))
	}
}

// 错误处理
const errorHandler = (error, config) => {
	// 隐藏加载中
	if (config.showLoading !== false) {
		uni.hideLoading()
	}

	// 网络错误处理
	let errorMsg = this.$t('net.networkConnectionAbnormal');
	if (err.errMsg.includes('timeout')) {
		errorMsg = this.$t('net.timeout');
	}

	uni.showToast({
		title: errorMsg,
		icon: 'none'
	});

	console.error('请求错误:', error)
	return Promise.reject(error)
}

// 封装请求方法
const request = (options = {}) => {
	// 默认配置
	const config = {
		method: 'GET',
		showLoading: true,
		loadingText: t('net.loading'),
		...options
	}

	// 请求拦截
	const requestOptions = requestInterceptor(config)

	return new Promise((resolve, reject) => {
		uni.request({
			...requestOptions,
			success: (response) => {
				try {
					const result = responseInterceptor(response, config)
					resolve(result)
				} catch (err) {
					reject(err)
				}
			},
			fail: (error) => {
				const err = errorHandler(error, config)
				reject(err)
			},
			// 请求完成（无论成功失败都会执行）
			complete: () => {
				// 可以在这里添加一些请求完成后的通用处理
			}
		})
	})
}

// 封装常用请求方法
const http = {
	get(url, data = {}, options = {}) {
		return request({
			url,
			data,
			method: 'GET',
			...options
		})
	},

	post(url, data = {}, options = {}) {
		return request({
			url,
			data,
			method: 'POST',
			...options
		})
	},

	put(url, data = {}, options = {}) {
		return request({
			url,
			data,
			method: 'PUT',
			...options
		})
	},

	delete(url, data = {}, options = {}) {
		return request({
			url,
			data,
			method: 'DELETE',
			...options
		})
	}
}

export default http